home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / c_edit.arc / ED3.C < prev    next >
C/C++ Source or Header  |  1991-09-08  |  18KB  |  943 lines
  1. /* ED3.C */
  2.  
  3. #include "ed0.c"
  4. #include "ed1.ccc" 
  5. int readfile = -1;    /* separate read and write files */
  6. int writefile = -1;    /* -1 for inactive, file channel no. for active */
  7. char rfilename[SYSFNMAX];    /* file names */
  8. char wfilename[SYSFNMAX];
  9. char databuf[MAXLEN1];        /* single buffer replaces redundant buffers */
  10. fileclear()        /* initializes filenames to zero length */
  11. {
  12.     rfilename[0] = EOS;
  13.     wfilename[0] = EOS;
  14. }
  15. append(args) char *args;
  16. {
  17. int file;
  18. int n;
  19. int topline;
  20. char locfn[SYSFNMAX];
  21.     if (name1(args,locfn)==ERR) {
  22.         return;
  23.     }
  24.     if (locfn[0]==EOS) {
  25.         message("no file argument");
  26.         return;
  27.     }
  28.     if ((file=sysopen(locfn,"r"))==ERR) {
  29.         message("file not found");
  30.         return;
  31.     }
  32.     while ((n=readline(file,databuf,MAXLEN))>=0) {
  33.         if (n>MAXLEN) {
  34.             message("line truncated");
  35.             n=MAXLEN;
  36.         }
  37.         if (bufins(databuf,n)==ERR) {
  38.             break;
  39.         }
  40.         if (bufdn()==ERR) {
  41.             break;
  42.         }
  43.     }
  44.     sysclose(file);
  45.     topline=max(1,bufln()-SCRNL2);
  46.     bufout(topline,2,SCRNL2);
  47.     bufgo(topline);
  48. }
  49. change(args,begin,end) char *args; int begin,end;
  50. {
  51. char oldline[MAXLEN1];
  52. char newline[MAXLEN1];
  53. char oldpat[MAXLEN1];
  54. char newpat[MAXLEN1];
  55. int from, to, col, n, k;
  56.     if (get2args(args,&from,&to)==ERR) {
  57.         if (check2mark(begin,end,&from,&to)==ERR){
  58.             sysabort();
  59.             return;
  60.         }
  61.     }
  62.     scr_chr_attr(SETINTENSE);
  63.     fmtsout("search mask ?    ",0);
  64.     getcmnd(oldpat,15);
  65.     fmtcrlf();
  66.     if(oldpat[0]==EOS) {
  67.         return;
  68.     }
  69.     pmtline();
  70.     scr_chr_attr(SETINTENSE);
  71.     fmtsout("change mask ?    ",0);
  72.     getcmnd(newpat,15);
  73.     fmtcrlf();
  74.     while (from<=to) {
  75.         if (chkkey()==YES) {
  76.             break;
  77.         }
  78.         if (bufgo(from++)==ERR) {
  79.             sysabort();
  80.             break;
  81.         }
  82.         if (bufatbot()==YES) {
  83.             sysabort();
  84.             break;
  85.         }
  86.         n=bufgetln(oldline,MAXLEN);
  87.         n=min(n,MAXLEN);
  88.         oldline[n]=EOS;
  89.         if (oldpat[0]=='^') {
  90.             if (amatch(oldline,oldpat+1,NO)==YES) {
  91.                 k=replace(oldline,newline,
  92.                     oldpat+1,newpat,0);
  93.                 if (k==ERR) {
  94.                     sysabort();
  95.                     return;
  96.                 }
  97.                 fmtcrlf();
  98.                 putdec(bufln(),5);
  99.                 fmtsout(newline,5);
  100.                 outdeol();
  101.                 bufrepl(newline,k);
  102.             }
  103.             continue;
  104.         }
  105.         if ((col=amatch(oldline,oldpat,YES))>=0) {
  106.             k=replace(oldline,newline,
  107.                 oldpat,newpat,col);
  108.             if (k==ERR) {
  109.                 sysabort();
  110.                 return;
  111.             }
  112.             fmtcrlf();
  113.             putdec(bufln(),5);
  114.             fmtsout(newline,5);
  115.             outdeol();
  116.             bufrepl(newline,k);
  117.         }
  118.     }
  119.     fmtcrlf();
  120. }
  121. clear()
  122. {
  123.     if (chkbuf()==YES) {
  124.         outclr();
  125.         outxy(0,SCRNL1);
  126.         bufnew();
  127.         message("buffer cleared");
  128.         return(YES);
  129.     }
  130.     else{
  131.         return(NO);
  132.     }
  133. }
  134. delete(args,begin,end) char *args; int begin,end;
  135. {
  136. int from, to;
  137.     if(get2args(args,&from,&to)==ERR) {
  138.         if (check2mark(begin,end,&from,&to)==ERR){
  139.             sysabort();
  140.             return;
  141.         }
  142.     }
  143.     if (from>to) {
  144.         return;
  145.     }
  146.     if (edpick(from,to)==OK){
  147.         message ("deleted lines saved in pick buffer");
  148.     }
  149.     if (bufgo(from)==ERR) {
  150.         return;
  151.     }
  152.     if (bufndel(to-from+1)==ERR) {
  153.         sysabort();
  154.         return;
  155.     }
  156.     bufout(bufln(),1,SCRNL1);
  157. }
  158. find()
  159. {
  160.     return(suurch(bufln()+1,HUGE,YES));
  161. }
  162. list(args,begin,end) char *args; int begin,end;
  163. {
  164. int n;
  165. int from, to, line, oldline;
  166.     oldline=bufln();
  167.     if (get2args(args,&from,&to)==ERR) {
  168.         if (check2mark(begin,end,&from,&to)==ERR) {
  169.             sysabort();
  170.             return;
  171.         }
  172.     }
  173.     line=from;
  174.     while (line<=to) {
  175.         fmtassn(NO);
  176.         if (chkkey()==YES) {
  177.             break;
  178.         }
  179.         fmtassn(YES);
  180.         if (bufgo(line++)!=OK) {
  181.             break;
  182.         }
  183.         if (bufatbot()) {
  184.             sysabort();
  185.             break;
  186.         }
  187.         n=bufgetln(databuf,MAXLEN1);
  188.         n=min(n,MAXLEN);
  189.         databuf[n]=CR;
  190.         fmtsout(databuf,0);
  191.         fmtcrlf();
  192.     }
  193.     fmtassn(NO);
  194.     bufgo(oldline);
  195. }
  196. extract(args,begin,end) char *args; int begin,end;
  197.     /* write indicated line range to writefile */
  198. {
  199. /*char args1[SCRNW1];
  200. char *argp;
  201. int file;
  202. char locfn[SYSFNMAX];    */
  203. int oldline, from, to, n;
  204.     if (writefile == -1) {
  205.         message("file not opened");
  206.         return;
  207.     }
  208.     oldline = bufln();
  209.     if (get2args(args,&from,&to)==ERR) {/* from and to are line range */
  210.         if (check2mark(begin,end,&from,&to)==ERR){
  211.             return;
  212.         }
  213.     }
  214. /*    message("enter file name");  */ /* request the file name */
  215. /*    getcmnd(args1,0);
  216.     argp=skipbl(args1);
  217.     if (syschkfn(argp)==ERR) {
  218.         return;
  219.     }
  220.     syscopfn(argp,locfn);
  221.     if (locfn[0]==EOS) {
  222.         message("no file argument");
  223.         return;
  224.     }
  225.     if ((file=sysopen(locfn,"w"))==ERR){
  226.         return;
  227.     }    */
  228.     if (bufgo(from)==ERR){
  229.        /*      sysclose(file);    */
  230.         return;
  231.     }
  232.     while ((bufatbot()==NO)&(bufln()<=to)) {    /* do the writing */
  233.         n=bufgetln(databuf,MAXLEN);
  234.         n=min(n,MAXLEN);
  235.         if (pushline(writefile,databuf,n)==ERR){
  236.             break;
  237.         }
  238.         if (bufdn()==ERR) {
  239.             break;
  240.         }
  241.     }
  242.     bufgo(oldline);
  243. /*      sysclose(file);    */  /* close the file */
  244. }
  245. openf (args,flag) char *args; int flag;
  246. {
  247. /* open a file for reading */
  248. char locfn [SYSFNMAX];
  249. int n;
  250. int file;
  251. int topline;
  252.     if (readfile > 0) {        /* check for open readfile */
  253.         message("read file still open");
  254.         return;
  255.     }
  256.     if (flag==YES) {
  257.         if (name1(args,locfn)==ERR) {
  258.             return;
  259.         }
  260.     }
  261.     else  {
  262.         if (name3(args,locfn)==ERR) {
  263.             return;
  264.         }
  265.     }
  266.     if (locfn[0]==EOS) {
  267.         message("no file argument");
  268.         return;
  269.     }
  270.     if (chkbuf()==NO) {
  271.         return;
  272.     }
  273.     if ((file=sysopen(locfn,"r"))==ERR) {
  274.         message("file not found");
  275.         return;
  276.     }
  277.     syscopfn(locfn, rfilename);    /* make the file name the readfile */
  278.     readfile = file;
  279.     pmtrfile(rfilename);
  280.     bufnew();
  281. }
  282. getit (args) char *args;    /* new: add n lines to buffer if room */
  283. {
  284. int n;
  285. int topline;
  286. int nlines,npoint;
  287.     if (readfile == -1) {
  288.         message ("no read file");
  289.         return;
  290.     }
  291.     pmtrfile(rfilename);
  292.     if (getarg(args,&nlines)==ERR) {
  293.         return;
  294.     }
  295.     if (nlines<1) {
  296.         return;
  297.     }
  298.     if (bufgo(HUGE)==ERR) {
  299.         return;
  300.     }
  301.     npoint=1;
  302.     while (npoint<=nlines) {    /* add the lines */
  303.         npoint++;
  304.         if ((n=readline(readfile,databuf,MAXLEN))>=0) {
  305.             if (n>MAXLEN) {
  306.                 message("line truncated");
  307.                 n=MAXLEN;
  308.             }
  309.             if (buf1ins(databuf,n)==ERR) {
  310.                 bufgo(1);
  311.                 topline=max(1,bufln()-SCRNL2);
  312.                 bufout(topline,2,SCRNL2);
  313.                 bufgo(topline);
  314.                 return;
  315.             }
  316.             if (bufdn()==ERR) {
  317.                 break;
  318.             }
  319.         }
  320.         else {
  321.             npoint = HUGE;       /* reached end of file - close it */
  322.             sysclose(readfile);
  323.             readfile = -1;
  324.             rfilename[0] = EOS;
  325.             pmtrfile(rfilename);
  326.         }
  327.     }
  328.     bufgo(1);
  329.     topline=max(1,bufln()-SCRNL2);
  330.     bufout(topline,2,SCRNL2);
  331.     bufgo(topline);
  332. }
  333. rest (args) char *args; /* new: try to read rest of readfile into buffer */
  334. {
  335. int n;
  336. int topline;
  337.     if (readfile == -1) {
  338.         message ("no read file");
  339.         return;
  340.     }
  341.     pmtrfile(rfilename);
  342. /* if buffer has been changed and not saved, give option of clearing, */
  343. /* otherwise add to end of buffer */
  344.     if(bufchng()==YES) {
  345.         scr_chr_attr(SETINTENSE);
  346.  
  347.         fmtsout("buffer not saved. clear? ",0);
  348.         scr_chr_attr(SETFAINT);
  349.         pmtline();
  350.         if (tolower(syscout(syscin()))=='y'){
  351.             outclr();
  352.             outxy(0,SCRNL1);
  353.             bufnew();
  354.             message("buffer cleared");
  355.         }
  356.         else {
  357.             bufgo(HUGE);
  358.         }
  359.     }
  360.     else{
  361.         outclr();
  362.         outxy(0,SCRNL1);
  363.         bufnew();
  364.         message("buffer cleared");
  365.  
  366.     }
  367.     while ((n=readline(readfile,databuf,MAXLEN))>=0) {
  368.         if (n>MAXLEN) {
  369.             message("line truncated");
  370.             n=MAXLEN;
  371.         }
  372.         if (buf1ins(databuf,n)==ERR) {
  373.             bufgo(1);
  374.             topline=max(1,bufln()-SCRNL2);
  375.             bufout(topline,2,SCRNL2);
  376.             bufgo(topline);
  377.             return;
  378.         }
  379.         if (bufdn()==ERR) {
  380.             break;
  381.         }
  382.     }
  383.     sysclose(readfile);    /* close file if all read */
  384.     readfile = -1;
  385.     rfilename[0] = EOS;
  386.     pmtrfile(rfilename);
  387.     bufgo(1);
  388.     topline=max(1,bufln()-SCRNL2);
  389.     bufout(topline,2,SCRNL2);
  390.     bufgo(topline);
  391. }
  392. rename(args) char *args;    /* new: change name of writefile */
  393. {
  394.     if (writefile == -1) {
  395.         message("no write file - call name");
  396.         return;
  397.     }
  398.     sysclose(writefile);
  399.     writefile = -1;
  400.     wfilename[0]=EOS;
  401.     pmtwfile(wfilename);
  402.     if (name0(args,wfilename)==ERR) {
  403.         return;
  404.     }
  405.     pmtwfile(wfilename);
  406. }
  407. name(args) char *args;        /* altered definition: name the writefile */
  408. {
  409.     if (writefile > 0) {
  410.         message("write file open");
  411.         return;
  412.     }
  413.     if (name0(args,wfilename)==ERR){
  414.         return;
  415.     }
  416.     pmtwfile(wfilename);
  417. }
  418. name0(args,wfilename) char *args, *wfilename;    /* names new writefile */
  419. {
  420. int file;
  421.     args=skiparg(args);
  422.     args=skipbl(args);
  423.     if (syschkfn(args)==ERR) {
  424.         return(ERR);
  425.     }
  426.     syscopfn(args,wfilename);
  427.     if ((file=sysopen(wfilename,"r"))!=ERR) {
  428.         sysclose(file);
  429.         message("disk file exists");
  430.         return(ERR);
  431.     }
  432.     if ((file=syscreate(wfilename))==ERR) {
  433.         return(ERR);
  434.     }
  435.     writefile = file;
  436.     return(OK);
  437. }
  438. delname(args) char *args;    /* new: similar to old resave command, */
  439. {                /* but doesn't automatically write file */
  440.     if (writefile > 0) {
  441.         message("write file open");
  442.         return;
  443.     }
  444.     if (name2(args,wfilename)==ERR){
  445.         return;
  446.     }
  447.     pmtwfile(wfilename);
  448. }
  449. name2(args,wfilename) char *args, *wfilename;    /* open writefile: no error */
  450. {                        /* file exists */
  451. int file;
  452.     args=skiparg(args);
  453.     args=skipbl(args);
  454.     if (syschkfn(args)==ERR) {
  455.         return(ERR);
  456.     }
  457.     syscopfn(args,wfilename);
  458.     if ((file=sysopen(wfilename,"w"))==ERR) {
  459.         return(ERR);
  460.     }
  461.     writefile = file;
  462.     return(OK);
  463. }
  464. name1(args,filename) char *args, *filename;
  465. {
  466.     args=skiparg(args);
  467.     args=skipbl(args);
  468.     if (syschkfn(args)==ERR) {
  469.         return(ERR);
  470.     }
  471.     syscopfn(args,filename);
  472.     return(OK);
  473. }
  474. name3(args,filename) char *args, *filename;
  475. {
  476.     if (syschkfn(args)==ERR) {
  477.         return(ERR);
  478.     }
  479.     syscopfn(args,filename);
  480.     return(OK);
  481. }
  482. count(args) char *args;  /* get repeat count for buffer macro replay */
  483. {
  484. int n;
  485.     if (getarg(args,&n)==ERR) {
  486.         return;
  487.     }
  488.     syscount(n);
  489. }
  490. writel(args) char *args;    /* new: write first n lines of buffer to */
  491. {                /* writefile and delete from buffer */
  492. int n, to;
  493.     if (writefile == -1) {
  494.         message("file not opened");
  495.         return;
  496.     }
  497.     if (getarg(args,&to)==ERR) {
  498.         return;
  499.     }
  500.     if (bufgo(1)==ERR) {
  501.         sysclose(writefile);
  502.         writefile = -1;
  503.         wfilename[0] = EOS;
  504.         pmtwfile(wfilename);
  505.         return;
  506.     }
  507.     while ((bufatbot()==NO)&(bufln()<=to)) {
  508.         n=bufgetln(databuf,MAXLEN);
  509.         n=min(n,MAXLEN);
  510.         if (pushline(writefile,databuf,n)==ERR) {
  511.             return;
  512.         }
  513.         if (bufdn()==ERR) {
  514.             return;
  515.         }
  516.     }
  517.     if (bufgo(1)==ERR) {
  518.         return;
  519.     }
  520.     if (bufndel(to)==ERR){
  521.         return;
  522.     }
  523.     bufout(bufln(),1,SCRNL1);
  524.     if (bufatbot()) {
  525.         bufsaved();
  526.     }
  527.     bufgo(1);
  528. }
  529. save()
  530. {
  531. int n, oldline;
  532.     if (writefile == -1) {             /* changed to writefile */
  533.         message("file not opened");     /* file assumed already open */
  534.         return;
  535.     }
  536.     oldline=bufln();
  537.     if (bufgo(1)==ERR) {
  538.         sysclose(writefile);    /* close the writefile if error */
  539.         writefile = -1;
  540.         wfilename[0]=EOS;
  541.         pmtwfile(wfilename);
  542.         return;
  543.     }
  544.     while (bufatbot()==NO) {
  545.         n=bufgetln(databuf,MAXLEN);
  546.         n=min(n,MAXLEN);
  547.         if (pushline(writefile,databuf,n)==ERR) {
  548.             break;
  549.         }
  550.         if (bufdn()==ERR) {
  551.             break;
  552.         }
  553.     }
  554.     if (bufatbot()) {
  555.         bufsaved();
  556.     }
  557.     bufgo(oldline);
  558.                     /* writefile no longer closed */
  559. }
  560. closeread()                /* new: close the readfile */
  561. {
  562.     if (readfile!= -1) {
  563.         sysclose(readfile);
  564.         readfile= -1;
  565.         rfilename[0]=EOS;
  566.         pmtrfile(rfilename);
  567.     }
  568. }
  569. closewrite()                /* new: close the writefile */
  570. {
  571.     if (writefile != -1) {
  572.         sysclose(writefile);
  573.         writefile= -1;
  574.         wfilename[0]=EOS;
  575.         pmtwfile(wfilename);
  576.     }
  577. }
  578. search (args,begin,end) char *args; int begin,end;
  579. {
  580. int from, to;
  581.     if (get2args(args,&from,&to)==ERR) {
  582.         if (check2mark(begin,end,&from,&to)==ERR) {
  583.             sysabort();
  584.             return;
  585.         }
  586.     }
  587.     suurch(from,to,NO);
  588. }
  589. suurch(from,to,flag) int from, to, flag;   /* old "search1" */
  590. {
  591.                     /* now uses module buffer */
  592. char pat [MAXLEN1];
  593. int col, n;
  594.     scr_chr_attr(SETINTENSE);
  595.     fmtsout("search mask ?    ",0);
  596.     getcmnd(pat,15);
  597.     fmtcrlf();
  598.     if (pat[0]==EOS) {
  599.         return (-1);
  600.     }
  601.     while (from<=to) {
  602.         if (chkkey()==YES) {
  603.             break;
  604.         }
  605.         if (bufgo(from++)==ERR) {
  606.             sysabort();
  607.             break;
  608.         }
  609.         if (bufatbot()==YES) {
  610.             sysabort();
  611.             break;
  612.         }
  613.         n=bufgetln(databuf,MAXLEN);
  614.         n=min(n,MAXLEN);
  615.         databuf[n]=EOS;
  616.         if (pat[0]=='^') {
  617.             if (amatch(databuf,pat+1,NO)==0) {
  618.                 if (flag==NO) {
  619.                     fmtcrlf();
  620.                     putdec(bufln(),5);
  621.                     fmtsout(databuf,5);
  622.                     outdeol();
  623.                 }
  624.                 else {
  625.                     return(0);
  626.                 }
  627.             }
  628.             continue;
  629.         }
  630.         if ((col=amatch(databuf,pat,YES))>=0) {
  631.             if (flag==NO) {
  632.                 fmtcrlf();
  633.                 putdec(bufln(),5);
  634.                 fmtsout(databuf,5);
  635.                 outdeol();
  636.             }
  637.             else {
  638.                 return(col);
  639.             }
  640.         }
  641.     }
  642.     if (flag==YES) {
  643.         return(-1);
  644.     }
  645.     else {
  646.         fmtcrlf();
  647.     }
  648. }
  649. tabs(args) char *args;
  650. {
  651. int n,junk;
  652.     if (get2args(args,&n,&junk)==ERR) {
  653.         sysabort();
  654.         return;
  655.     }
  656.     fmtset(n);
  657. }
  658. chkbuf()
  659. {
  660.     if (bufchng()==NO) {
  661.         return(YES);
  662.     }
  663.     scr_chr_attr(SETINTENSE);
  664.     fmtsout("Buffer not saved.  Proceed  ? ",0);
  665.     scr_chr_attr(SETFAINT);
  666.     pmtline();
  667.     if (tolower(syscout(syscin()))!='y') {
  668.         fmtcrlf();
  669.         message("cancelled");
  670.         return(NO);
  671.     }
  672.     else {
  673.         fmtcrlf();
  674.         return(YES);
  675.     }
  676. }
  677. message(s) char *s;
  678. {
  679.         scr_chr_attr(SETINTENSE);
  680.         fmtsout(s,0);
  681.         fmtcrlf();
  682.         scr_chr_attr(SETFAINT);
  683. }
  684. getarg(args,val) char *args; int *val;    /* new: get a single argument */
  685. {
  686.     args=skiparg(args);
  687.     args=skipbl(args);
  688.     if (*args==EOS) {
  689.         *val=1;
  690.         return(ERR);
  691.     }
  692.     if (number(args,val)==NO) {
  693.         message("bad argument");
  694.         return(ERR);
  695.     }
  696.     return(OK);
  697. }
  698. /* new: get three arguments                        */
  699. get3args(args,val1,val2,val3) char *args; int *val1, *val2,*val3;
  700. {
  701.     args=skiparg(args);
  702.     args=skipbl(args);
  703.     if (*args==EOS) {
  704.         return(ERR);
  705.     }
  706.     if (number(args,val1)==NO) {
  707.         message("bad argument");
  708.         return(ERR);
  709.     }
  710.     args=skiparg(args);
  711.     args=skipbl(args);
  712.     if(*args==EOS) {
  713.         return(ERR);
  714.     }
  715.     if (number(args,val2)==NO) {
  716.         message("bad argument");
  717.         return(ERR);
  718.     }
  719.     args=skiparg(args);
  720.     args=skipbl(args);
  721.     if(*args==EOS) {
  722.         return(ERR);
  723.     }
  724.     if (number(args,val3)==NO) {
  725.         message("bad argument");
  726.         return(ERR);
  727.     }
  728.     else {
  729.         return(OK);
  730.     }
  731. }
  732. get2args(args,val1,val2) char *args; int *val1, *val2;
  733. {
  734.     args=skiparg(args);
  735.     args=skipbl(args);
  736.     if (*args==EOS) {
  737. /*        *val1=1;
  738.         *val2=HUGE;   */
  739.         return(ERR);
  740.     }
  741.     if (number(args,val1)==NO) {
  742.         message("bad argument");
  743.         return(ERR);
  744.     }
  745.     args=skiparg(args);
  746.     args=skipbl(args);
  747.     if(*args==EOS) {
  748.     /*    *val2=HUGE;  */
  749.         return(ERR);
  750.     }
  751.     if (number(args,val2)==NO) {
  752.         message("bad argument");
  753.         return(ERR);
  754.     }
  755.     else {
  756.         return(OK);
  757.     }
  758. }
  759. skiparg(args) char *args;
  760. {
  761.     while ((*args!=EOS)&(*args!=' ')) {
  762.         args++;
  763.     }
  764.     return(args);
  765. }
  766. skipbl(args) char *args;
  767. {
  768.     while(*args==' ') {
  769.         args++;
  770.     }
  771.     return(args);
  772. }
  773. chkkey()
  774. {
  775. int c;
  776.     c=syscstat();
  777.     if (c==-1) {        /* note correction from original version */
  778.         return(NO);
  779.     }
  780.     else if (c==' ') {
  781.         pmtline();
  782.         if (syscin()==' ') {
  783.             return(NO);
  784.         }
  785.     }
  786.     return(YES);
  787. }
  788. /*
  789. amatch(line,pat,col) char *line, *pat; int col;
  790. {
  791. int k;
  792.     k=0;
  793.     while (pat[k]!=EOS) {
  794.         if (pat[k]==line[col]) {
  795.             k++;
  796.             col++;
  797.         }
  798.         else if ((pat[k]=='?')&(line[col]!=EOS)) {
  799.             k++;
  800.             col++;
  801.         }
  802.         else {
  803.             return(NO);
  804.         }
  805.     }
  806.     return(YES);
  807. }
  808. */
  809. replace(oldline,newline,oldpat,newpat,col)
  810. char *oldline, *newline, *oldpat, *newpat; int col;
  811. {
  812. int k;
  813. char *tail, *pat;
  814.     k=0;
  815.     while (k<col) {
  816.         newline[k++]= *oldline++;
  817.     }
  818.     tail=oldline;
  819.     pat=oldpat;
  820.     while (*pat++!=EOS) {
  821.         tail++;
  822.     }
  823.     while (*newpat!=EOS) {
  824.         if (k>MAXLEN-1) {
  825.             message("new line too long");
  826.             sysabort();
  827.             return(ERR);
  828.         }
  829.         if (*newpat!='?') {
  830.             newline[k++]= *newpat++;
  831.             continue;
  832.         }
  833.         while (*oldpat!='?') {
  834.             if (*oldpat==EOS) {
  835.                 message(
  836.                 "too many ?'s in change mask"
  837.                 );
  838.                 sysabort();
  839.                 return(ERR);
  840.             }
  841.             oldpat++;
  842.             oldline++;
  843.         }
  844.         newline[k++]= *oldline++;
  845.         oldpat++;
  846.         newpat++;
  847.     }
  848.     while (*tail!=EOS) {
  849.         if (k>MAXLEN-1) {
  850.             message("new line too long");
  851.             sysabort();
  852.             return(ERR);
  853.         }
  854.         newline[k++]= *tail++;
  855.     }
  856.     newline[k]=EOS;
  857.     return(k);
  858. }
  859. copyit (args,begin,end,dest) char *args; int begin,end,dest;
  860.     /* new: copies "lenn" lines from "from"   */
  861. {                /* to "to" */
  862. int from,to,lenn;
  863. int topline;
  864.     if (get3args(args,&from,&to,&lenn)==ERR) {
  865.         if (check3mark(begin,end,dest,&from,&to,&lenn)==ERR) {
  866.             sysabort();
  867.             return;
  868.         }
  869.     }
  870.     if (to == from) {
  871.         return;
  872.     }
  873.     if ((to>from)&(to<=(from+lenn))) {
  874.         message("interleaving not permitted");
  875.         sysabort();
  876.         return;
  877.     }
  878.     bufcopy(from,to,lenn);
  879.     bufgo(1);
  880.     topline=max(1,bufln()-SCRNL2);
  881.     bufout(topline,2,SCRNL2);
  882.     bufgo(topline);
  883. }
  884. moveit (args,begin,end,dest) char *args; int begin,end,dest;
  885.  
  886.     /* new: moves "lenn" lines from "from" */
  887. {                /* to "to" - same as copyit except deletes */
  888. int from,to,lenn;        /* old lines */
  889. int topline;
  890.     if (get3args(args,&from,&to,&lenn)==ERR) {
  891.         if (check3mark(begin,end,dest,&from,&to,&lenn)==ERR) {
  892.             sysabort();
  893.             return;
  894.         }
  895.     }
  896.     if (to == from) {
  897.         return;
  898.     }
  899.     if ((to>from)&(to<=(from+lenn))) {
  900.         message("interleaving not permitted");
  901.         sysabort();
  902.         return;
  903.     }
  904.     bufcopy(from,to,lenn);
  905.     if (to>from){
  906.         bufgo(from);
  907.         bufndel(lenn);
  908.     }
  909.     else {
  910.         bufgo(from+lenn);
  911.         bufndel(lenn);
  912.     }
  913.     bufgo(1);
  914.     topline=max(1,bufln()-SCRNL2);
  915.     bufout(topline,2,SCRNL2);
  916.     bufgo(topline);
  917. }
  918. check2mark(begin,end,from,to) int begin,end,*from,*to;
  919. {
  920.     if ((begin==(-1))|(end==(-1))){
  921.         return(ERR);
  922.     }
  923.     if    (begin>end) {
  924.         return(ERR);
  925.     }
  926.     *from=begin;
  927.     *to=end;
  928.     return(OK);
  929. }
  930. check3mark(begin,end,dest,from,to,lenn) int begin,end,dest;
  931.     int *from,*to,*lenn;
  932. {
  933.     if ((begin==(-1))|(end==(-1))){
  934.         return(ERR);
  935.     }
  936.     if (begin>end) {
  937.         return(ERR);
  938.     }
  939.     *from=begin;
  940.     *to=dest;
  941.     *lenn=end-begin;
  942. }
  943.